package com.by.car.service.impl;

import com.by.car.dto.CarWDto;
import com.by.car.entity.CarBC;
import com.by.car.entity.ShopCartItem;
import com.by.car.mapper.CarMapper;
import com.by.car.service.CarService;
import com.by.car.redis.RedisCartUtil;
import com.by.car.vo.CarVo;
import com.by.car.vo.SkuVo;
import com.by.car.vo.SpuVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.*;

@Service
@Slf4j
public class CarServiceImpl implements CarService {
    @Autowired
    RedisCartUtil redisCartUtil;
    @Autowired
    CarMapper carMapper;

    // 获取当前用户ID（实际业务中应从登录信息获取，而非硬编码）!!!!!!!
    private static final int UserId = 23;


    //购物车商品添加
    @Override
    public int carInsert(CarWDto carWDto) {
        // 先查询该商品是否已在购物车中
        ShopCartItem existingItem = redisCartUtil.selectOnly(UserId, carWDto.getSkuId());

        if (existingItem != null){
            // 商品已存在，累加数量
            System.out.println("商品已存在，累加数量");
            existingItem.setCount(existingItem.getCount()+ carWDto.getCount());
            existingItem.setUpdateTime(LocalDateTime.now() );
            redisCartUtil.addCartItem(existingItem);
        }else {
            // 商品不存在，创建新的购物车项
            System.out.println("商品不存在，创建新的购物车项");
            CarBC carBC=carMapper.selectCarBC(carWDto.getSkuId());
            ShopCartItem shopCartItem=new ShopCartItem();

            shopCartItem.setUserId( UserId);
            shopCartItem.setCount(carWDto.getCount());
            shopCartItem.setUpdateTime(LocalDateTime.now() );
            BeanUtils.copyProperties(carBC,shopCartItem);
            //调用写好的redis方法
            redisCartUtil.addCartItem(shopCartItem);
        }

        return 0;
    }


    //查询购物车商品
    @Override
    public Map<Integer, List<CarVo>> carSelect() {
        Map<Integer, List<CarVo>> shopCarMap = new LinkedHashMap<>(); // 推荐用 LinkedHashMap 保持顺序
        List<CarVo> carVoList=new ArrayList<>();
        //先查询Redis有数据直接返回
        List<ShopCartItem> list=redisCartUtil.selectCarItem(UserId);
        if (list != null && !list.isEmpty()){
            System.out.println("redis不为空");
            log.info("查询购物车: userId={}, redisItems={}", UserId, list);
            //获取每个商品
            for (ShopCartItem item : list) {
                // 为每个商品补充额外信息
                CarVo carVo=new CarVo();
                SpuVo spuVo=carMapper.selectSpuVo(item.getSpuId());
                log.debug("SPU查询结果: spuId={}, result={}", item.getSpuId(), spuVo);
                SkuVo skuVo=carMapper.selectSkuVo(item.getSkuId());
                log.debug("SKU查询结果: skuId={}, result={}", item.getSkuId(), skuVo);

                // 检查对象是否为null，避免BeanUtils.copyProperties抛出异常
                if (skuVo != null) {
                    BeanUtils.copyProperties(skuVo, carVo);
                } else {
                    log.error("未找到SKU信息: skuId={}", item.getSkuId());
                    // 可以选择跳过这个商品或进行其他处理 跳过当前商品
                    continue;
                }

                if (spuVo != null) {
                    BeanUtils.copyProperties(spuVo, carVo);
                } else {
                    log.error("未找到SPU信息: spuId={}", item.getSpuId());
                }
                carVo.setShopId(item.getShopId());
                carVo.setCount(item.getCount());
                carVo.setOldPriceFee(item.getPriceFee());
                carVo.setIsChecked(item.getIsChecked());
                carVoList.add(carVo);
            }
            //将返回的商品按照“店铺”分组
            //Map<Integer,List<CarVo>> shopCarMap=new HashMap<>();
            // 遍历所有CarVo，按shopId分组
            for (CarVo carvo:carVoList) {
                Integer shopId=carvo.getShopId(); //获取店铺ID
                //检查Map中是否有该 shopId
                if (shopCarMap.containsKey(shopId)){
                    //有  加入商品信息
                    List<CarVo> existList=shopCarMap.get(shopId);
                    existList.add(carvo);
                }else {
                    //没 新建列表，加入CarVo，再放入Map
                    List<CarVo> newList =new ArrayList<>();
                    newList.add(carvo);
                    shopCarMap.put(shopId,newList);
                }
            }
            log.info("按照店铺分组，共{}个店铺",shopCarMap.size());

        }else {
            //Mybsql查询
            System.out.println("redis为空");

        }


        return shopCarMap;
    }


    //删除购物车商品
    @Override
    public int carDelete(int skuId) {
        //2. 先删除MySQL中的数据

        // 3. 无论MySQL中是否有数据，都删除Redis中的缓存
        redisCartUtil.deleteCartItem(UserId,skuId);
        return 0;
    }


    //查询购物车中sku种类
    @Override
    public int carSkuNum() {

        int sum=0;
        //redis查询统计
        Long skuCount=redisCartUtil.carSkuNum(UserId);
        // 2. Redis 有数据（可能为 0，代表空购物车）
        if (skuCount != null) {
            sum=skuCount.intValue();
        }
        //mysql查询统计

        return sum;
    }


    //更改商品选中状态
    @Override
    public int isChecked(int skuId) {
        //先获取对应商品信息
        ShopCartItem shopCartItem=redisCartUtil.selectOnly(UserId,skuId);
        //更改选中状态
        int ischecked=shopCartItem.getIsChecked();
        ischecked = (ischecked == 1) ? 0 : 1;
        shopCartItem.setIsChecked(ischecked);
        //重新存入，（自动覆盖）
        redisCartUtil.addCartItem(shopCartItem);

        return 0;
    }

    //商品状态全选
    @Override
    public int allIsChecked(int isChecked) {
        //获取购物车全部商品
        List<ShopCartItem> cartItems=redisCartUtil.selectCarItem(UserId);
        if (cartItems == null || cartItems.isEmpty()) {
            // 购物车为空，返回特定标识
            return -1;
        }
        // 批量更新所有商品的选中状态
        for (ShopCartItem item : cartItems) {
            item.setIsChecked(isChecked);
            item.setUpdateTime(LocalDateTime.now());
            // 覆盖更新到Redis
            redisCartUtil.addCartItem(item);
        }
        return 0;
    }


    //修改购物车中商品数量
    @Override
    public int updateNumber(CarWDto carWDto) {
        CarBC carBC=carMapper.selectCarBC(carWDto.getSkuId());
        ShopCartItem shopCartItem=new ShopCartItem();
        shopCartItem.setUserId( UserId);
        shopCartItem.setCount(carWDto.getCount());
        shopCartItem.setUpdateTime(LocalDateTime.now() );
        BeanUtils.copyProperties(carBC,shopCartItem);
        //调用写好的redis方法
        redisCartUtil.addCartItem(shopCartItem);
        return 0;
    }

    //修改购物车中商品sku
    @Override
    public int updateSku(int skuId,int oldSkuId) {

        // 先查询该商品
        ShopCartItem existingItem = redisCartUtil.selectOnly(UserId, oldSkuId);
            // 商品已存在，获取数量
            existingItem.setCount(existingItem.getCount());
            // 给新的SKU
            existingItem.setSkuId(skuId);
            existingItem.setUpdateTime(LocalDateTime.now() );
            redisCartUtil.addCartItem(existingItem);

            //还要删除旧的商品sku
            carDelete(oldSkuId);
        return 0;
    }




    //购物车传数据给订单
    @Override
    public List<CarWDto> CatToOrder(List<Integer> skulist) {
        List<CarWDto> list=new ArrayList<>();
        //遍历sku，分别查询，并加入集合
        for (int n:skulist) {
            CarWDto carWDto =new CarWDto();
            //查询出单个详情
            ShopCartItem shopCartItem=redisCartUtil.selectOnly(UserId,n);
            carWDto.setCount(shopCartItem.getCount());
            carWDto.setSkuId(n);
            list.add(carWDto);
        }
        return list;
    }










    @Override
    public List<CarWDto> querySelectGoodsFromCar(int userId) {
        List<CarWDto> carWDtoList =new ArrayList<>();//存放选中的商品

        //根据用户id查询购物列表
        List<ShopCartItem> list=redisCartUtil.selectCarItem(UserId);
        //遍历购物列表
        if(null==list || list.size()==0)
            return carWDtoList;
        //购物列表不为空  遍历
        list.forEach(el->{
            //判断当前商品是否是选 中的
            if(el.getIsChecked()==0){
                //记录当前sku
                CarWDto dto=new CarWDto();
                dto.setSkuId(el.getSkuId());
                dto.setCount(el.getCount());
                carWDtoList.add(dto);
            }
        });
        return carWDtoList;
    }


    @Override
    public int cleanCar(int userId) {
        //根据用户id查询购物列表
        List<ShopCartItem> list=redisCartUtil.selectCarItem(UserId);
        //遍历购物列表
        if(null==list || list.size()==0)
            return 0;
        //购物列表不为空  遍历
        list.forEach(el->{
            //判断当前商品是否是选 中的
            if(el.getIsChecked()==0){
                //如果当前sku选中  意味首生成了订单  将其从redis移除
                redisCartUtil.deleteCartItem(UserId,el.getSkuId());
            }
        });
        return 1;
    }

}
